//! 复合类型实现：列表(集)、字典(辞)、集合(汇)、元组(组)
//!
//! 设计原则：
//! - 列表：有序可重复元素集合
//! - 字典：键值对映射
//! - 集合：无序不重复元素集合  
//! - 元组：固定长度异构元素序列

use crate::interpreter::method::{Method, MethodType};
use crate::interpreter::value::{Value, ValueData, ValueWrapper};
use crate::type_system::boolean_null_types::BooleanUtils;
use std::collections::{HashMap, HashSet};

/// 列表类型(集)的方法实现
pub struct ListMethods;

impl ListMethods {
    /// 创建列表类型的所有内置方法
    pub fn create_all_methods() -> HashMap<String, Method> {
        let mut methods = HashMap::new();

        // 基本属性方法
        methods.insert("长度".to_string(), Self::create_length_method());
        methods.insert("是否空".to_string(), Self::create_is_empty_method());

        // 元素操作方法
        methods.insert("添加".to_string(), Self::create_push_method());
        methods.insert("插入".to_string(), Self::create_insert_method());
        methods.insert("移除".to_string(), Self::create_remove_method());
        methods.insert("获取".to_string(), Self::create_get_method());
        methods.insert("设置".to_string(), Self::create_set_method());
        methods.insert("弹出".to_string(), Self::create_pop_method());
        methods.insert("清空".to_string(), Self::create_clear_method());

        // 搜索和过滤方法
        methods.insert("包含".to_string(), Self::create_contains_method());
        methods.insert("索引".to_string(), Self::create_index_of_method());
        methods.insert("最后索引".to_string(), Self::create_last_index_of_method());
        methods.insert("计数".to_string(), Self::create_count_method());

        // 排序和反转方法
        methods.insert("排序".to_string(), Self::create_sort_method());
        methods.insert("反转".to_string(), Self::create_reverse_method());

        // 转换方法
        methods.insert("转字符串".to_string(), Self::create_to_string_method());
        methods.insert("连接".to_string(), Self::create_join_method());
        methods.insert("切片".to_string(), Self::create_slice_method());
        methods.insert("复制".to_string(), Self::create_clone_method());

        // 高级方法
        methods.insert("过滤".to_string(), Self::create_filter_method());
        methods.insert("映射".to_string(), Self::create_map_method());
        methods.insert("折叠".to_string(), Self::create_fold_method());
        methods.insert("去重".to_string(), Self::create_unique_method());
        methods.insert("打乱".to_string(), Self::create_shuffle_method());

        methods
    }

    /// 创建长度方法
    fn create_length_method() -> Method {
        Method::native(MethodType::Number, |args| {
            if let ValueData::List(elements) = &args[0].data {
                Ok(Value::number(elements.borrow().len() as f64))
            } else {
                Err("不是列表类型".to_string())
            }
        })
    }

    /// 创建是否空方法
    fn create_is_empty_method() -> Method {
        Method::native(MethodType::Boolean, |args| {
            if let ValueData::List(elements) = &args[0].data {
                Ok(Value::boolean(elements.borrow().is_empty()))
            } else {
                Err("不是列表类型".to_string())
            }
        })
    }

    /// 创建添加方法（在末尾添加元素）
    fn create_push_method() -> Method {
        Method::native(MethodType::List, |args| {
            if let ValueData::List(elements) = &args[0].data {
                if args.len() < 2 {
                    return Err("添加方法需要至少一个参数".to_string());
                }
                elements.borrow_mut().push(args[1].clone());
                Ok(Value::list(elements.borrow().clone()))
            } else {
                Err("不是列表类型".to_string())
            }
        })
    }

    /// 创建插入方法（在指定位置插入元素）
    fn create_insert_method() -> Method {
        Method::native(MethodType::List, |args| {
            if let (ValueData::List(elements), ValueData::Number(index)) =
                (&args[0].data, &args[1].data)
            {
                if args.len() < 3 {
                    return Err("插入方法需要索引和元素参数".to_string());
                }
                let idx = *index as usize;
                let mut list = elements.borrow_mut();
                if idx > list.len() {
                    return Err("索引超出范围".to_string());
                }
                list.insert(idx, args[2].clone());
                Ok(Value::list(list.clone()))
            } else {
                Err("插入方法需要列表、数字和元素参数".to_string())
            }
        })
    }

    /// 创建移除方法（移除指定位置的元素）
    fn create_remove_method() -> Method {
        Method::native(MethodType::List, |args| {
            if let (ValueData::List(elements), ValueData::Number(index)) =
                (&args[0].data, &args[1].data)
            {
                let idx = *index as usize;
                let mut list = elements.borrow_mut();
                if idx >= list.len() {
                    return Err("索引超出范围".to_string());
                }
                list.remove(idx);
                Ok(Value::list(list.clone()))
            } else {
                Err("移除方法需要列表和数字参数".to_string())
            }
        })
    }

    /// 创建获取方法（获取指定位置的元素）
    fn create_get_method() -> Method {
        Method::native(MethodType::Any, |args| {
            if let (ValueData::List(elements), ValueData::Number(index)) =
                (&args[0].data, &args[1].data)
            {
                let idx = *index as usize;
                let list = elements.borrow();
                if idx >= list.len() {
                    Ok(Value::null()) // 返回null表示越界
                } else {
                    Ok(list[idx].clone())
                }
            } else {
                Err("获取方法需要列表和数字参数".to_string())
            }
        })
    }

    /// 创建设置方法（设置指定位置的元素）
    fn create_set_method() -> Method {
        Method::native(MethodType::List, |args| {
            if let (ValueData::List(elements), ValueData::Number(index)) =
                (&args[0].data, &args[1].data)
            {
                if args.len() < 3 {
                    return Err("设置方法需要索引和值参数".to_string());
                }
                let idx = *index as usize;
                let mut list = elements.borrow_mut();
                if idx >= list.len() {
                    return Err("索引超出范围".to_string());
                }
                list[idx] = args[2].clone();
                Ok(Value::list(list.clone()))
            } else {
                Err("设置方法需要列表、数字和值参数".to_string())
            }
        })
    }

    /// 创建弹出方法（移除并返回最后一个元素）
    fn create_pop_method() -> Method {
        Method::native(MethodType::Any, |args| {
            if let ValueData::List(elements) = &args[0].data {
                let mut list = elements.borrow_mut();
                if list.is_empty() {
                    Ok(Value::null()) // 返回null表示空列表
                } else {
                    Ok(list.pop().unwrap())
                }
            } else {
                Err("不是列表类型".to_string())
            }
        })
    }

    /// 创建清空方法
    fn create_clear_method() -> Method {
        Method::native(MethodType::List, |args| {
            if let ValueData::List(elements) = &args[0].data {
                elements.borrow_mut().clear();
                Ok(Value::list(elements.borrow().clone()))
            } else {
                Err("不是列表类型".to_string())
            }
        })
    }

    /// 创建包含方法
    fn create_contains_method() -> Method {
        Method::native(MethodType::Boolean, |args| {
            if let (ValueData::List(elements), item) = (&args[0].data, &args[1]) {
                let list = elements.borrow();
                Ok(Value::boolean(list.contains(item)))
            } else {
                Err("包含方法需要列表和元素参数".to_string())
            }
        })
    }

    /// 创建索引方法（返回元素第一次出现的索引）
    fn create_index_of_method() -> Method {
        Method::native(MethodType::Number, |args| {
            if let (ValueData::List(elements), item) = (&args[0].data, &args[1]) {
                let list = elements.borrow();
                match list.iter().position(|x| x == item) {
                    Some(index) => Ok(Value::number(index as f64)),
                    None => Ok(Value::number(-1.0)), // 未找到返回-1
                }
            } else {
                Err("索引方法需要列表和元素参数".to_string())
            }
        })
    }

    /// 创建最后索引方法（返回元素最后一次出现的索引）
    fn create_last_index_of_method() -> Method {
        Method::native(MethodType::Number, |args| {
            if let (ValueData::List(elements), item) = (&args[0].data, &args[1]) {
                let list = elements.borrow();
                match list.iter().rposition(|x| x == item) {
                    Some(index) => Ok(Value::number(index as f64)),
                    None => Ok(Value::number(-1.0)), // 未找到返回-1
                }
            } else {
                Err("最后索引方法需要列表和元素参数".to_string())
            }
        })
    }

    /// 创建计数方法（统计元素出现的次数）
    fn create_count_method() -> Method {
        Method::native(MethodType::Number, |args| {
            if let (ValueData::List(elements), item) = (&args[0].data, &args[1]) {
                let list = elements.borrow();
                let count = list.iter().filter(|x| *x == item).count();
                Ok(Value::number(count as f64))
            } else {
                Err("计数方法需要列表和元素参数".to_string())
            }
        })
    }

    /// 创建排序方法
    fn create_sort_method() -> Method {
        Method::native(MethodType::List, |args| {
            if let ValueData::List(elements) = &args[0].data {
                let mut list = elements.borrow_mut();
                // 简单的排序：数字按数值，字符串按字典序，其他类型保持不变
                list.sort_by(|a, b| {
                    match (&a.data, &b.data) {
                        (ValueData::Number(n1), ValueData::Number(n2)) => {
                            n1.partial_cmp(n2).unwrap()
                        }
                        (ValueData::String(s1), ValueData::String(s2)) => s1.cmp(s2),
                        _ => std::cmp::Ordering::Equal, // 其他类型认为相等
                    }
                });
                Ok(Value::list(list.clone()))
            } else {
                Err("不是列表类型".to_string())
            }
        })
    }

    /// 创建反转方法
    fn create_reverse_method() -> Method {
        Method::native(MethodType::List, |args| {
            if let ValueData::List(elements) = &args[0].data {
                let mut list = elements.borrow_mut();
                list.reverse();
                Ok(Value::list(list.clone()))
            } else {
                Err("不是列表类型".to_string())
            }
        })
    }

    /// 创建转字符串方法
    fn create_to_string_method() -> Method {
        Method::native(MethodType::String, |args| {
            if let ValueData::List(elements) = &args[0].data {
                let list = elements.borrow();
                let parts: Vec<String> = list
                    .iter()
                    .map(|v| match &v.data {
                        ValueData::String(s) => s.clone(),
                        _ => format!("{:?}", v.data), // 简化显示
                    })
                    .collect();
                Ok(Value::string(format!("[{}]", parts.join(", "))))
            } else {
                Err("不是列表类型".to_string())
            }
        })
    }

    /// 创建连接方法（将列表元素连接成字符串）
    fn create_join_method() -> Method {
        Method::native(MethodType::String, |args| {
            if let (ValueData::List(elements), ValueData::String(separator)) =
                (&args[0].data, &args[1].data)
            {
                let list = elements.borrow();
                let parts: Vec<String> = list
                    .iter()
                    .map(|v| match &v.data {
                        ValueData::String(s) => s.clone(),
                        ValueData::Number(n) => n.to_string(),
                        _ => format!("{:?}", v.data), // 简化显示
                    })
                    .collect();
                Ok(Value::string(parts.join(separator)))
            } else {
                Err("连接方法需要列表和字符串参数".to_string())
            }
        })
    }

    /// 创建切片方法（返回子列表）
    fn create_slice_method() -> Method {
        Method::native(MethodType::List, |args| {
            if let ValueData::List(elements) = &args[0].data {
                if args.len() < 2 {
                    return Err("切片方法需要至少一个参数".to_string());
                }
                let start = if let ValueData::Number(n) = &args[1].data {
                    *n as usize
                } else {
                    return Err("切片开始索引必须是数字".to_string());
                };

                let end = if args.len() >= 3 {
                    if let ValueData::Number(n) = &args[2].data {
                        *n as usize
                    } else {
                        return Err("切片结束索引必须是数字".to_string());
                    }
                } else {
                    elements.borrow().len()
                };

                let list = elements.borrow();
                if start >= list.len() {
                    Ok(Value::list(vec![]))
                } else {
                    let end_idx = std::cmp::min(end, list.len());
                    Ok(Value::list(list[start..end_idx].to_vec()))
                }
            } else {
                Err("不是列表类型".to_string())
            }
        })
    }

    /// 创建复制方法
    fn create_clone_method() -> Method {
        Method::native(MethodType::List, |args| {
            if let ValueData::List(elements) = &args[0].data {
                let list = elements.borrow();
                Ok(Value::list(list.clone()))
            } else {
                Err("不是列表类型".to_string())
            }
        })
    }

    /// 创建过滤方法（根据条件过滤元素）
    fn create_filter_method() -> Method {
        Method::native(MethodType::List, |args| {
            if let ValueData::List(elements) = &args[0].data {
                if args.len() < 2 {
                    return Err("过滤方法需要过滤条件".to_string());
                }
                let list = elements.borrow();
                let filtered: Vec<Value> = list
                    .iter()
                    .filter(|item| {
                        // 这里简化处理：如果提供了函数，调用函数判断；否则使用元素本身作为布尔值
                        if args.len() >= 2 {
                            // 简化：假设第二个参数是函数，这里直接返回true
                            true
                        } else {
                            BooleanUtils::is_truthy(*item)
                        }
                    })
                    .cloned()
                    .collect();
                Ok(Value::list(filtered))
            } else {
                Err("不是列表类型".to_string())
            }
        })
    }

    /// 创建映射方法（对每个元素应用函数）
    fn create_map_method() -> Method {
        Method::native(MethodType::List, |args| {
            if let ValueData::List(elements) = &args[0].data {
                if args.len() < 2 {
                    return Err("映射方法需要映射函数".to_string());
                }
                let list = elements.borrow();
                // 简化处理：直接返回原列表
                Ok(Value::list(list.clone()))
            } else {
                Err("不是列表类型".to_string())
            }
        })
    }

    /// 创建折叠方法（累积计算）
    fn create_fold_method() -> Method {
        Method::native(MethodType::Any, |args| {
            if let ValueData::List(_elements) = &args[0].data {
                if args.len() < 2 {
                    return Err("折叠方法需要初始值".to_string());
                }
                // 简化处理：返回初始值
                Ok(args[1].clone())
            } else {
                Err("不是列表类型".to_string())
            }
        })
    }

    /// 创建去重方法
    fn create_unique_method() -> Method {
        Method::native(MethodType::List, |args| {
            if let ValueData::List(elements) = &args[0].data {
                let list = elements.borrow();
                let mut seen = Vec::new();
                let unique: Vec<Value> = list
                    .iter()
                    .filter(|item: &&Value| {
                        if seen.contains(*item) {
                            false
                        } else {
                            seen.push((*item).clone());
                            true
                        }
                    })
                    .cloned()
                    .collect();
                Ok(Value::list(unique))
            } else {
                Err("不是列表类型".to_string())
            }
        })
    }

    /// 创建打乱方法（随机打乱顺序）
    fn create_shuffle_method() -> Method {
        Method::native(MethodType::List, |args| {
            if let ValueData::List(elements) = &args[0].data {
                let mut list = elements.borrow_mut();
                // 简单的Fisher-Yates洗牌算法
                let len = list.len();
                for i in 0..len {
                    let j = (i as f64 * (len as f64).sqrt() * 1000.0).floor() as usize % len;
                    list.swap(i, j);
                }
                Ok(Value::list(list.clone()))
            } else {
                Err("不是列表类型".to_string())
            }
        })
    }
}

/// 字典类型(辞)的方法实现
pub struct DictMethods;

impl DictMethods {
    /// 创建字典类型的所有内置方法
    pub fn create_all_methods() -> HashMap<String, Method> {
        let mut methods = HashMap::new();

        // 基本属性方法
        methods.insert("长度".to_string(), Self::create_length_method());
        methods.insert("是否空".to_string(), Self::create_is_empty_method());

        // 键值操作方法
        methods.insert("获取".to_string(), Self::create_get_method());
        methods.insert("设置".to_string(), Self::create_set_method());
        methods.insert("移除".to_string(), Self::create_remove_method());
        methods.insert("包含键".to_string(), Self::create_contains_key_method());
        methods.insert("包含值".to_string(), Self::create_contains_value_method());

        // 批量操作方法
        methods.insert("键".to_string(), Self::create_keys_method());
        methods.insert("值".to_string(), Self::create_values_method());
        methods.insert("键值对".to_string(), Self::create_items_method());
        methods.insert("清空".to_string(), Self::create_clear_method());

        // 更新和合并方法
        methods.insert("更新".to_string(), Self::create_update_method());
        methods.insert("合并".to_string(), Self::create_merge_method());

        // 转换方法
        methods.insert("转字符串".to_string(), Self::create_to_string_method());
        methods.insert("复制".to_string(), Self::create_clone_method());

        methods
    }

    /// 创建长度方法
    fn create_length_method() -> Method {
        Method::native(MethodType::Number, |args| {
            if let ValueData::Dict(items) = &args[0].data {
                Ok(Value::number(items.borrow().len() as f64))
            } else {
                Err("不是字典类型".to_string())
            }
        })
    }

    /// 创建是否空方法
    fn create_is_empty_method() -> Method {
        Method::native(MethodType::Boolean, |args| {
            if let ValueData::Dict(items) = &args[0].data {
                Ok(Value::boolean(items.borrow().is_empty()))
            } else {
                Err("不是字典类型".to_string())
            }
        })
    }

    /// 创建获取方法
    fn create_get_method() -> Method {
        Method::native(MethodType::Any, |args| {
            if let (ValueData::Dict(items), ValueData::String(key)) = (&args[0].data, &args[1].data)
            {
                let dict = items.borrow();
                match dict.get(key) {
                    Some(value) => Ok(value.clone()),
                    None => Ok(Value::null()), // 键不存在返回null
                }
            } else {
                Err("获取方法需要字典和字符串参数".to_string())
            }
        })
    }

    /// 创建设置方法
    fn create_set_method() -> Method {
        Method::native(MethodType::Dict, |args| {
            if let (ValueData::Dict(items), ValueData::String(key)) = (&args[0].data, &args[1].data)
            {
                if args.len() < 3 {
                    return Err("设置方法需要键和值参数".to_string());
                }
                items.borrow_mut().insert(key.clone(), args[2].clone());
                Ok(Value::dict(items.borrow().clone()))
            } else {
                Err("设置方法需要字典、字符串和值参数".to_string())
            }
        })
    }

    /// 创建移除方法
    fn create_remove_method() -> Method {
        Method::native(MethodType::Dict, |args| {
            if let (ValueData::Dict(items), ValueData::String(key)) = (&args[0].data, &args[1].data)
            {
                let mut dict = items.borrow_mut();
                dict.remove(key);
                Ok(Value::dict(dict.clone()))
            } else {
                Err("移除方法需要字典和字符串参数".to_string())
            }
        })
    }

    /// 创建包含键方法
    fn create_contains_key_method() -> Method {
        Method::native(MethodType::Boolean, |args| {
            if let (ValueData::Dict(items), ValueData::String(key)) = (&args[0].data, &args[1].data)
            {
                let dict = items.borrow();
                Ok(Value::boolean(dict.contains_key(key)))
            } else {
                Err("包含键方法需要字典和字符串参数".to_string())
            }
        })
    }

    /// 创建包含值方法
    fn create_contains_value_method() -> Method {
        Method::native(MethodType::Boolean, |args| {
            if let (ValueData::Dict(items), value) = (&args[0].data, &args[1]) {
                let dict = items.borrow();
                Ok(Value::boolean(dict.values().any(|v| v == value)))
            } else {
                Err("包含值方法需要字典和值参数".to_string())
            }
        })
    }

    /// 创建键方法（返回所有键的列表）
    fn create_keys_method() -> Method {
        Method::native(MethodType::List, |args| {
            if let ValueData::Dict(items) = &args[0].data {
                let dict = items.borrow();
                let keys: Vec<Value> = dict.keys().map(|k| Value::string(k.to_string())).collect();
                Ok(Value::list(keys))
            } else {
                Err("不是字典类型".to_string())
            }
        })
    }

    /// 创建值方法（返回所有值的列表）
    fn create_values_method() -> Method {
        Method::native(MethodType::List, |args| {
            if let ValueData::Dict(items) = &args[0].data {
                let dict = items.borrow();
                let values: Vec<Value> = dict.values().cloned().collect();
                Ok(Value::list(values))
            } else {
                Err("不是字典类型".to_string())
            }
        })
    }

    /// 创建键值对方法（返回键值对列表）
    fn create_items_method() -> Method {
        Method::native(MethodType::List, |args| {
            if let ValueData::Dict(items) = &args[0].data {
                let dict = items.borrow();
                let items: Vec<Value> = dict
                    .iter()
                    .map(|(k, v)| {
                        let pair = vec![Value::string(k.to_string()), v.clone()];
                        Value::list(pair)
                    })
                    .collect();
                Ok(Value::list(items))
            } else {
                Err("不是字典类型".to_string())
            }
        })
    }

    /// 创建清空方法
    fn create_clear_method() -> Method {
        Method::native(MethodType::Dict, |args| {
            if let ValueData::Dict(items) = &args[0].data {
                items.borrow_mut().clear();
                Ok(Value::dict(items.borrow().clone()))
            } else {
                Err("不是字典类型".to_string())
            }
        })
    }

    /// 创建更新方法（用另一个字典更新当前字典）
    fn create_update_method() -> Method {
        Method::native(MethodType::Dict, |args| {
            if let (ValueData::Dict(items), ValueData::Dict(other_items)) =
                (&args[0].data, &args[1].data)
            {
                let mut dict = items.borrow_mut();
                let other_dict = other_items.borrow();
                for (key, value) in other_dict.iter() {
                    dict.insert(key.clone(), value.clone());
                }
                Ok(Value::dict(dict.clone()))
            } else {
                Err("更新方法需要两个字典参数".to_string())
            }
        })
    }

    /// 创建合并方法（合并两个字典，返回新字典）
    fn create_merge_method() -> Method {
        Method::native(MethodType::Dict, |args| {
            if let (ValueData::Dict(items1), ValueData::Dict(items2)) =
                (&args[0].data, &args[1].data)
            {
                let dict1 = items1.borrow();
                let dict2 = items2.borrow();
                let mut merged = dict1.clone();
                for (key, value) in dict2.iter() {
                    merged.insert(key.clone(), value.clone());
                }
                Ok(Value::dict(merged))
            } else {
                Err("合并方法需要两个字典参数".to_string())
            }
        })
    }

    /// 创建转字符串方法
    fn create_to_string_method() -> Method {
        Method::native(MethodType::String, |args| {
            if let ValueData::Dict(items) = &args[0].data {
                let dict = items.borrow();
                let pairs: Vec<String> = dict
                    .iter()
                    .map(|(k, v)| format!("{}: {:?}", k, v.data))
                    .collect();
                Ok(Value::string(format!("{{{}}}", pairs.join(", "))))
            } else {
                Err("不是字典类型".to_string())
            }
        })
    }

    /// 创建复制方法
    fn create_clone_method() -> Method {
        Method::native(MethodType::Dict, |args| {
            if let ValueData::Dict(items) = &args[0].data {
                let dict = items.borrow();
                Ok(Value::dict(dict.clone()))
            } else {
                Err("不是字典类型".to_string())
            }
        })
    }
}

/// 集合类型(汇)的方法实现
pub struct SetMethods;

impl SetMethods {
    /// 创建集合类型的所有内置方法
    pub fn create_all_methods() -> HashMap<String, Method> {
        let mut methods = HashMap::new();

        // 基本属性方法
        methods.insert("长度".to_string(), Self::create_length_method());
        methods.insert("是否空".to_string(), Self::create_is_empty_method());

        // 元素操作方法
        methods.insert("添加".to_string(), Self::create_add_method());
        methods.insert("移除".to_string(), Self::create_remove_method());
        methods.insert("包含".to_string(), Self::create_contains_method());
        methods.insert("清空".to_string(), Self::create_clear_method());

        // 集合运算方法
        methods.insert("并集".to_string(), Self::create_union_method());
        methods.insert("交集".to_string(), Self::create_intersection_method());
        methods.insert("差集".to_string(), Self::create_difference_method());
        methods.insert(
            "对称差集".to_string(),
            Self::create_symmetric_difference_method(),
        );

        // 关系方法
        methods.insert("是子集".to_string(), Self::create_is_subset_method());
        methods.insert("是超集".to_string(), Self::create_is_superset_method());
        methods.insert("是相等".to_string(), Self::create_is_equal_method());

        // 转换方法
        methods.insert("转列表".to_string(), Self::create_to_list_method());
        methods.insert("转字符串".to_string(), Self::create_to_string_method());

        methods
    }

    /// 创建长度方法
    fn create_length_method() -> Method {
        Method::native(MethodType::Number, |args| {
            if let ValueData::Set(items) = &args[0].data {
                Ok(Value::number(items.borrow().len() as f64))
            } else {
                Err("不是集合类型".to_string())
            }
        })
    }

    /// 创建是否空方法
    fn create_is_empty_method() -> Method {
        Method::native(MethodType::Boolean, |args| {
            if let ValueData::Set(items) = &args[0].data {
                Ok(Value::boolean(items.borrow().is_empty()))
            } else {
                Err("不是集合类型".to_string())
            }
        })
    }

    /// 创建添加方法
    fn create_add_method() -> Method {
        Method::native(MethodType::Set, |args| {
            if let (ValueData::Set(items), item) = (&args[0].data, &args[1]) {
                let mut set = items.borrow_mut();
                set.insert(ValueWrapper(item.clone()));
                let result: Vec<Value> = set.iter().map(|v| v.0.clone()).collect();
                Ok(Value::set(result))
            } else {
                Err("添加方法需要集合和元素参数".to_string())
            }
        })
    }

    /// 创建移除方法
    fn create_remove_method() -> Method {
        Method::native(MethodType::Set, |args| {
            if let (ValueData::Set(items), item) = (&args[0].data, &args[1]) {
                let mut set = items.borrow_mut();
                set.remove(&ValueWrapper(item.clone()));
                let result: Vec<Value> = set.iter().map(|v| v.0.clone()).collect();
                Ok(Value::set(result))
            } else {
                Err("移除方法需要集合和元素参数".to_string())
            }
        })
    }

    /// 创建包含方法
    fn create_contains_method() -> Method {
        Method::native(MethodType::Boolean, |args| {
            if let (ValueData::Set(items), item) = (&args[0].data, &args[1]) {
                let set = items.borrow();
                Ok(Value::boolean(set.contains(&ValueWrapper(item.clone()))))
            } else {
                Err("包含方法需要集合和元素参数".to_string())
            }
        })
    }

    /// 创建清空方法
    fn create_clear_method() -> Method {
        Method::native(MethodType::Set, |args| {
            if let ValueData::Set(items) = &args[0].data {
                items.borrow_mut().clear();
                let result: Vec<Value> = items.borrow().iter().map(|v| v.0.clone()).collect();
                Ok(Value::set(result))
            } else {
                Err("不是集合类型".to_string())
            }
        })
    }

    /// 创建并集方法
    fn create_union_method() -> Method {
        Method::native(MethodType::Set, |args| {
            if let (ValueData::Set(items1), ValueData::Set(items2)) = (&args[0].data, &args[1].data)
            {
                let set1 = items1.borrow();
                let set2 = items2.borrow();
                let mut result = set1.clone();
                for item in set2.iter() {
                    result.insert(item.clone());
                }
                let final_result: Vec<Value> = result.iter().map(|v| v.0.clone()).collect();
                Ok(Value::set(final_result))
            } else {
                Err("并集方法需要两个集合参数".to_string())
            }
        })
    }

    /// 创建交集方法
    fn create_intersection_method() -> Method {
        Method::native(MethodType::Set, |args| {
            if let (ValueData::Set(items1), ValueData::Set(items2)) = (&args[0].data, &args[1].data)
            {
                let set1 = items1.borrow();
                let set2 = items2.borrow();
                let result: HashSet<ValueWrapper> = set1
                    .iter()
                    .filter(|item| set2.contains(item))
                    .cloned()
                    .collect();
                let final_result: Vec<Value> = result.iter().map(|v| v.0.clone()).collect();
                Ok(Value::set(final_result))
            } else {
                Err("交集方法需要两个集合参数".to_string())
            }
        })
    }

    /// 创建差集方法
    fn create_difference_method() -> Method {
        Method::native(MethodType::Set, |args| {
            if let (ValueData::Set(items1), ValueData::Set(items2)) = (&args[0].data, &args[1].data)
            {
                let set1 = items1.borrow();
                let set2 = items2.borrow();
                let result: HashSet<ValueWrapper> = set1
                    .iter()
                    .filter(|item| !set2.contains(item))
                    .cloned()
                    .collect();
                let final_result: Vec<Value> = result.iter().map(|v| v.0.clone()).collect();
                Ok(Value::set(final_result))
            } else {
                Err("差集方法需要两个集合参数".to_string())
            }
        })
    }

    /// 创建对称差集方法
    fn create_symmetric_difference_method() -> Method {
        Method::native(MethodType::Set, |args| {
            if let (ValueData::Set(items1), ValueData::Set(items2)) = (&args[0].data, &args[1].data)
            {
                let set1 = items1.borrow();
                let set2 = items2.borrow();
                let mut result: HashSet<ValueWrapper> = set1
                    .iter()
                    .filter(|item| !set2.contains(item))
                    .cloned()
                    .collect();
                for item in set2.iter() {
                    if !set1.contains(item) {
                        result.insert(item.clone());
                    }
                }
                let final_result: Vec<Value> = result.iter().map(|v| v.0.clone()).collect();
                Ok(Value::set(final_result))
            } else {
                Err("对称差集方法需要两个集合参数".to_string())
            }
        })
    }

    /// 创建是子集方法
    fn create_is_subset_method() -> Method {
        Method::native(MethodType::Boolean, |args| {
            if let (ValueData::Set(items1), ValueData::Set(items2)) = (&args[0].data, &args[1].data)
            {
                let set1 = items1.borrow();
                let set2 = items2.borrow();
                let is_subset = set1.iter().all(|item| set2.contains(item));
                Ok(Value::boolean(is_subset))
            } else {
                Err("是子集方法需要两个集合参数".to_string())
            }
        })
    }

    /// 创建是超集方法
    fn create_is_superset_method() -> Method {
        Method::native(MethodType::Boolean, |args| {
            if let (ValueData::Set(items1), ValueData::Set(items2)) = (&args[0].data, &args[1].data)
            {
                let set1 = items1.borrow();
                let set2 = items2.borrow();
                let is_superset = set2.iter().all(|item| set1.contains(item));
                Ok(Value::boolean(is_superset))
            } else {
                Err("是超集方法需要两个集合参数".to_string())
            }
        })
    }

    /// 创建是相等方法
    fn create_is_equal_method() -> Method {
        Method::native(MethodType::Boolean, |args| {
            if let (ValueData::Set(items1), ValueData::Set(items2)) = (&args[0].data, &args[1].data)
            {
                let set1 = items1.borrow();
                let set2 = items2.borrow();
                // 比较两个集合的内容是否相等
                if set1.len() != set2.len() {
                    return Ok(Value::boolean(false));
                }
                for item in set1.iter() {
                    if !set2.contains(item) {
                        return Ok(Value::boolean(false));
                    }
                }
                Ok(Value::boolean(true))
            } else {
                Err("是相等方法需要两个集合参数".to_string())
            }
        })
    }

    /// 创建转列表方法
    fn create_to_list_method() -> Method {
        Method::native(MethodType::List, |args| {
            if let ValueData::Set(items) = &args[0].data {
                let set = items.borrow();
                let list: Vec<Value> = set.iter().map(|v| v.0.clone()).collect();
                Ok(Value::list(list))
            } else {
                Err("不是集合类型".to_string())
            }
        })
    }

    /// 创建转字符串方法
    fn create_to_string_method() -> Method {
        Method::native(MethodType::String, |args| {
            if let ValueData::Set(items) = &args[0].data {
                let set = items.borrow();
                let elements: Vec<String> = set.iter().map(|v| format!("{:?}", v)).collect();
                Ok(Value::string(format!("{{{}}}", elements.join(", "))))
            } else {
                Err("不是集合类型".to_string())
            }
        })
    }
}

/// 元组类型(组)的方法实现
pub struct TupleMethods;

impl TupleMethods {
    /// 创建元组类型的所有内置方法
    pub fn create_all_methods() -> HashMap<String, Method> {
        let mut methods = HashMap::new();

        // 基本属性方法
        methods.insert("长度".to_string(), Self::create_length_method());
        methods.insert("获取".to_string(), Self::create_get_method());
        methods.insert("包含".to_string(), Self::create_contains_method());
        methods.insert("索引".to_string(), Self::create_index_of_method());

        // 转换方法
        methods.insert("转列表".to_string(), Self::create_to_list_method());
        methods.insert("转字符串".to_string(), Self::create_to_string_method());
        methods.insert("复制".to_string(), Self::create_clone_method());

        methods
    }

    /// 创建长度方法
    fn create_length_method() -> Method {
        Method::native(MethodType::Number, |args| {
            if let ValueData::Tuple(elements) = &args[0].data {
                Ok(Value::number(elements.len() as f64))
            } else {
                Err("不是元组类型".to_string())
            }
        })
    }

    /// 创建获取方法
    fn create_get_method() -> Method {
        Method::native(MethodType::Any, |args| {
            if let (ValueData::Tuple(elements), ValueData::Number(index)) =
                (&args[0].data, &args[1].data)
            {
                let idx = *index as usize;
                if idx >= elements.len() {
                    Ok(Value::null()) // 索引越界返回null
                } else {
                    Ok(elements[idx].clone())
                }
            } else {
                Err("获取方法需要元组和数字参数".to_string())
            }
        })
    }

    /// 创建包含方法
    fn create_contains_method() -> Method {
        Method::native(MethodType::Boolean, |args| {
            if let (ValueData::Tuple(elements), item) = (&args[0].data, &args[1]) {
                Ok(Value::boolean(elements.contains(item)))
            } else {
                Err("包含方法需要元组和元素参数".to_string())
            }
        })
    }

    /// 创建索引方法
    fn create_index_of_method() -> Method {
        Method::native(MethodType::Number, |args| {
            if let (ValueData::Tuple(elements), item) = (&args[0].data, &args[1]) {
                match elements.iter().position(|x| x == item) {
                    Some(index) => Ok(Value::number(index as f64)),
                    None => Ok(Value::number(-1.0)), // 未找到返回-1
                }
            } else {
                Err("索引方法需要元组和元素参数".to_string())
            }
        })
    }

    /// 创建转列表方法
    fn create_to_list_method() -> Method {
        Method::native(MethodType::List, |args| {
            if let ValueData::Tuple(elements) = &args[0].data {
                Ok(Value::list(elements.clone()))
            } else {
                Err("不是元组类型".to_string())
            }
        })
    }

    /// 创建转字符串方法
    fn create_to_string_method() -> Method {
        Method::native(MethodType::String, |args| {
            if let ValueData::Tuple(elements) = &args[0].data {
                let parts: Vec<String> = elements
                    .iter()
                    .map(|v| match &v.data {
                        ValueData::String(s) => s.clone(),
                        _ => format!("{:?}", v.data), // 简化显示
                    })
                    .collect();
                Ok(Value::string(format!("({})", parts.join(", "))))
            } else {
                Err("不是元组类型".to_string())
            }
        })
    }

    /// 创建复制方法
    fn create_clone_method() -> Method {
        Method::native(MethodType::Tuple, |args| {
            if let ValueData::Tuple(elements) = &args[0].data {
                Ok(Value::tuple(elements.clone()))
            } else {
                Err("不是元组类型".to_string())
            }
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_list_methods_creation() {
        let methods = ListMethods::create_all_methods();

        // 检查基本方法是否存在
        assert!(methods.contains_key("长度"));
        assert!(methods.contains_key("是否空"));
        assert!(methods.contains_key("添加"));
        assert!(methods.contains_key("获取"));
        assert!(methods.contains_key("设置"));
        assert!(methods.contains_key("包含"));
        assert!(methods.contains_key("排序"));
        assert!(methods.contains_key("反转"));

        // 检查高级方法是否存在
        assert!(methods.contains_key("过滤"));
        assert!(methods.contains_key("映射"));
        assert!(methods.contains_key("折叠"));
    }

    #[test]
    fn test_dict_methods_creation() {
        let methods = DictMethods::create_all_methods();

        // 检查基本方法是否存在
        assert!(methods.contains_key("长度"));
        assert!(methods.contains_key("是否空"));
        assert!(methods.contains_key("获取"));
        assert!(methods.contains_key("设置"));
        assert!(methods.contains_key("移除"));
        assert!(methods.contains_key("包含键"));
        assert!(methods.contains_key("键"));
        assert!(methods.contains_key("值"));

        // 检查高级方法是否存在
        assert!(methods.contains_key("更新"));
        assert!(methods.contains_key("合并"));
    }

    #[test]
    fn test_set_methods_creation() {
        let methods = SetMethods::create_all_methods();

        // 检查基本方法是否存在
        assert!(methods.contains_key("长度"));
        assert!(methods.contains_key("是否空"));
        assert!(methods.contains_key("添加"));
        assert!(methods.contains_key("移除"));
        assert!(methods.contains_key("包含"));

        // 检查集合运算方法是否存在
        assert!(methods.contains_key("并集"));
        assert!(methods.contains_key("交集"));
        assert!(methods.contains_key("差集"));
        assert!(methods.contains_key("对称差集"));

        // 检查关系方法是否存在
        assert!(methods.contains_key("是子集"));
        assert!(methods.contains_key("是超集"));
        assert!(methods.contains_key("是相等"));
    }

    #[test]
    fn test_tuple_methods_creation() {
        let methods = TupleMethods::create_all_methods();

        // 检查基本方法是否存在
        assert!(methods.contains_key("长度"));
        assert!(methods.contains_key("获取"));
        assert!(methods.contains_key("包含"));
        assert!(methods.contains_key("索引"));

        // 检查转换方法是否存在
        assert!(methods.contains_key("转列表"));
        assert!(methods.contains_key("转字符串"));
    }
}
